// 智能内容填写工具 - 小红书发布流程（基于真实HTML）
class ContentFiller {
  constructor(contentData) {
    this.contentData = contentData;
    this.maxRetries = 10;
    this.retryInterval = 1000;
    this.uploadAttempted = false; // 添加上传状态标记，防止重复上传
    
    // 真人操作延时配置
    this.humanDelay = {
      min: 3000,    // 最小延时3秒
      max: 5000,    // 最大延时5秒
      typing: {     // 打字延时
        min: 100,   // 每个字符最小延时100ms
        max: 300    // 每个字符最大延时300ms
      }
    };
    
    console.log('🚀 ContentFiller 初始化完成');
    console.log('📋 内容数据:', JSON.stringify(this.contentData, null, 2));
    console.log('⏱️ 真人操作延时配置:', this.humanDelay);
  }

  // 真人操作延时
  async humanDelayWait(description = '操作') {
    const delay = Math.random() * (this.humanDelay.max - this.humanDelay.min) + this.humanDelay.min;
    console.log(`⏱️ ${description}，等待 ${Math.round(delay)}ms...`);
    await new Promise(resolve => setTimeout(resolve, delay));
  }

  // 模拟真人打字
  async humanTyping(element, text, description = '输入') {
    console.log(`⌨️ 开始${description}: "${text}"`);
    
    // 清空现有内容
    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
      element.value = '';
    } else if (element.contentEditable === 'true') {
      element.innerHTML = '';
      element.textContent = ''; // 确保完全清空
    }
    
    // 模拟逐字输入
    for (let i = 0; i < text.length; i++) {
      const char = text[i];
      const typingDelay = Math.random() * (this.humanDelay.typing.max - this.humanDelay.typing.min) + this.humanDelay.typing.min;
      
      if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
        element.value += char;
        element.dispatchEvent(new Event('input', { bubbles: true }));
      } else if (element.contentEditable === 'true') {
        // 使用textContent而不是innerHTML，确保内容在一行显示
        // 避免HTML标签导致的换行问题
        element.textContent += char;
        element.dispatchEvent(new Event('input', { bubbles: true }));
      }
      
      // 随机延时，模拟真人打字节奏
      await new Promise(resolve => setTimeout(resolve, typingDelay));
      
      // 偶尔停顿，模拟思考
      if (Math.random() < 0.1) { // 10%概率停顿
        const pauseDelay = Math.random() * 500 + 200; // 200-700ms停顿
        await new Promise(resolve => setTimeout(resolve, pauseDelay));
      }
    }
    
    // 输入完成后触发change事件
    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
      element.dispatchEvent(new Event('change', { bubbles: true }));
    }
    
    console.log(`✅ ${description}完成`);
  }

  // 等待页面加载
  async waitForPageLoad() {
    return new Promise(resolve => {
      let attempts = 0;
      const checkInterval = setInterval(() => {
        attempts++;
        
        // 检查页面是否加载完成
        if (document.readyState === 'complete' && 
            document.querySelector('body') && 
            attempts >= 3) {
          clearInterval(checkInterval);
          resolve();
        }
        
        // 超时保护
        if (attempts >= 20) {
          clearInterval(checkInterval);
          console.warn('页面加载超时，继续执行');
          resolve();
        }
      }, 500);
    });
  }

  // 第一步：点击发布笔记（如果不在发布页面）
  async clickPublishNote() {
    console.log('🎯 第一步：检查是否在发布页面...');
    
    // 等待页面完全加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 检查是否已经在发布页面
    const publishContainer = document.querySelector('.publish-container');
    if (publishContainer) {
      console.log('✅ 已经在发布页面，跳过点击发布笔记');
      return true;
    }
    
    // 查找并点击"发布笔记"按钮
    const publishButton = this.findElement([
      'div.publish-video .btn',
      'div[class*="publish"] span:contains("发布笔记")',
      'span:contains("发布笔记")'
    ]);
    
    if (publishButton) {
      // 模拟真人操作延时
      await this.humanDelayWait('点击发布笔记前');
      
      publishButton.click();
      console.log('✅ 已点击发布笔记');
      
      // 模拟真人等待页面跳转
      await this.humanDelayWait('等待页面跳转');
      
      // 等待页面跳转
      await new Promise(resolve => setTimeout(resolve, 3000));
      return true;
    }
    
    console.warn('❌ 未找到发布笔记按钮');
    return false;
  }

  // 第二步：选择内容类型
  async selectContentType() {
    console.log('🎯 第二步：选择内容类型...');
    
    // 等待类型选择标签加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    const contentType = this.contentData.content_type;
    let targetTab = '';
    
    // 根据内容类型选择对应的标签
    switch (contentType) {
      case 'image':
        targetTab = '上传图文';
        break;
      case 'video':
        targetTab = '上传视频';
        break;
      case 'article':
        targetTab = '写长文';
        break;
      default:
        targetTab = '上传图文';
    }
    
    console.log(`选择内容类型: ${targetTab}`);
    
    // 查找对应的标签并点击
    const tabs = document.querySelectorAll('.creator-tab');
    let targetTabElement = null;
    
    for (const tab of tabs) {
      const tabText = tab.textContent || tab.innerText;
      if (tabText.includes(targetTab)) {
        targetTabElement = tab;
        break;
      }
    }
    
    if (targetTabElement) {
      // 模拟真人操作延时
      await this.humanDelayWait('选择内容类型前');
      
      targetTabElement.click();
      console.log(`✅ 已选择${targetTab}标签`);
      
      // 模拟真人等待标签切换
      await this.humanDelayWait('等待标签切换');
      
      // 等待标签切换完成
      await new Promise(resolve => setTimeout(resolve, 1500));
      return true;
    }
    
    console.warn(`❌ 未找到${targetTab}标签`);
    return false;
  }

  // 第三步：填写内容信息
  async fillContentInfo() {
    console.log('🎯 第三步：填写内容信息...');
    
    // 等待表单加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    let successCount = 0;
    
    // 填写标题
    if (await this.fillTitle()) successCount++;
    
    // 填写内容描述（包括标签）
    if (await this.fillContent()) successCount++;
    
    console.log(`✅ 内容信息填写完成，成功填写 ${successCount}/2 项（标题和内容）`);
    return successCount;
  }

  // 填写标题
  async fillTitle() {
    console.log('🎯 开始填写标题...');
    
    // 等待页面完全加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 使用更简单的选择器策略
    const titleSelectors = [
      // 精确选择器
      'input[placeholder*="标题"]',
      'textarea[placeholder*="标题"]',
      'input[name="title"]',
      'input[data-testid="title"]',
      'div[contenteditable="true"][placeholder*="标题"]',
      
      // 小红书特有的选择器
      'input[class*="title"]',
      'textarea[class*="title"]',
      
      // 通过父容器查找
      'div[class*="title"] input',
      'div[class*="title"] textarea',
      
      // 通用输入框（作为备选）
      'input[type="text"]',
      'textarea',
      'div[contenteditable="true"]'
    ];
    
    console.log('🔍 查找标题输入框...');
    const titleInput = await this.findElementWithRetry(titleSelectors, '标题');
    
    if (titleInput) {
      console.log('✅ 找到标题输入框:', titleInput.tagName, titleInput.className);
      
      try {
        // 模拟真人操作延时
        await this.humanDelayWait('开始填写标题前');
        
        let title = this.contentData.title
        if (title.length > 20) {
          title = this.contentData.title.slice(0, 20)
        } else {
          title = this.contentData.title
        }
        // 使用真人打字方式填写标题
        await this.humanTyping(titleInput, title, '标题');
        
        // 触发焦点事件
        titleInput.focus();
        titleInput.dispatchEvent(new Event('focus', { bubbles: true }));
        
        console.log('✅ 标题填写完成:', title);
        return true;
      } catch (error) {
        console.error('❌ 标题填写失败:', error);
        return false;
      }
    }
    
    console.warn('❌ 未找到标题输入框，尝试手动查找...');
    
    // 手动查找策略：遍历所有输入框
    const allInputs = document.querySelectorAll('input, textarea, [contenteditable="true"]');
    console.log(`🔍 页面共有 ${allInputs.length} 个输入元素`);
    
    for (let i = 0; i < allInputs.length; i++) {
      const input = allInputs[i];
      const placeholder = input.placeholder || '';
      const className = input.className || '';
      const tagName = input.tagName;
      
      console.log(`🔍 检查元素 ${i + 1}: ${tagName}, placeholder="${placeholder}", class="${className}"`);
      
      // 如果找到可能的标题输入框
      if (placeholder.includes('标题') || className.includes('title') || 
          (tagName === 'INPUT' && input.type === 'text' && !input.value)) {
        console.log('🎯 尝试使用备选标题输入框:', input);
        
        try {
          // 模拟真人操作延时
          await this.humanDelayWait('使用备选输入框填写标题前');
          
          // 使用真人打字方式
          await this.humanTyping(input, this.contentData.title, '标题');
          
          console.log('✅ 使用备选输入框填写标题成功');
          return true;
        } catch (error) {
          console.error('❌ 备选输入框填写失败:', error);
        }
      }
    }
    
    console.warn('❌ 所有标题填写策略都失败了');
    return false;
  }

  // 填写内容描述
  async fillContent() {
    console.log('🎯 开始填写内容描述...');
    
    // 等待页面完全加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 小红书2024年新版编辑器选择器（TipTap/ProseMirror）
    const contentSelectors = [
      // TipTap/ProseMirror编辑器选择器（最新版小红书）
      'div.tiptap.ProseMirror[contenteditable="true"]',
      'div.ProseMirror[contenteditable="true"]',
      'div.tiptap[contenteditable="true"]',
      'div[role="textbox"].tiptap',
      'div[role="textbox"].ProseMirror',
      
      // 旧版Quill编辑器选择器（向后兼容）
      'div.ql-editor[contenteditable="true"]',
      'div[class*="ql-editor"][contenteditable="true"]',
      'div[class*="editor"][contenteditable="true"]',
      
      // 通用选择器
      'div[role="textbox"]',
      'div[contenteditable="true"]',
      
      // 传统选择器
      'textarea[placeholder*="内容"]',
      'textarea[placeholder*="描述"]',
      'textarea[name="content"]',
      'textarea[name="description"]'
    ];
    
    console.log('🔍 查找内容输入框...');
    const contentInput = await this.findElementWithRetry(contentSelectors, '内容');
    
    if (contentInput) {
      console.log('✅ 找到内容输入框:', contentInput.tagName, contentInput.className);
      
      try {
        // 模拟真人操作延时
        await this.humanDelayWait('开始填写内容前');

        let fullContent = null
        // 构建完整的内容（包括标签），确保在一行显示
        if (this.contentData.content) {
          fullContent = this.contentData.content.replace(/\n/g, ' ').replace(/\r/g, ' ');
        } else {
          fullContent = this.contentData.title.replace(/\n/g, ' ').replace(/\r/g, ' ');
        }
        
        // 如果有标签，添加到内容末尾，使用空格连接确保在同一行
        if (this.contentData.tags && this.contentData.tags.trim()) {
          const tags = this.contentData.tags.split(',').map(tag => tag.trim()).filter(tag => tag);
          if (tags.length > 0) {
            // 使用空格分隔标签，确保所有内容在一行
            fullContent += ' ' + tags.map(tag => `#${tag}`).join(' ');
          }
        }
        
        if (contentInput.contentEditable === 'true') {
          // 检查是否是ProseMirror编辑器
          if (contentInput.classList.contains('ProseMirror') || contentInput.classList.contains('tiptap')) {
            console.log('🎯 识别为ProseMirror编辑器，使用特殊处理方式');
            
            // 聚焦编辑器
            contentInput.focus();
            await new Promise(resolve => setTimeout(resolve, 200));
            
            // 使用execCommand插入文本（更兼容）
            try {
              // 选择全部内容并删除
              document.execCommand('selectAll', false, null);
              document.execCommand('delete', false, null);
              
              // 插入新内容
              document.execCommand('insertText', false, fullContent);
              
              console.log('✅ 使用execCommand方式插入内容成功');
            } catch (error) {
              console.log('⚠️ execCommand失败，尝试DOM操作:', error);
              
              // 备用方案：直接操作DOM
              const pElement = contentInput.querySelector('p');
              if (pElement) {
                pElement.textContent = fullContent;
                pElement.classList.remove('is-empty', 'is-editor-empty');
              } else {
                contentInput.innerHTML = `<p>${fullContent}</p>`;
              }
              
              // 触发事件
              contentInput.dispatchEvent(new Event('input', { bubbles: true }));
              contentInput.dispatchEvent(new Event('change', { bubbles: true }));
            }
          } else {
            // 普通的contenteditable元素
            await this.humanTyping(contentInput, fullContent, '内容');
          }
          
          // 触发必要的事件
          contentInput.dispatchEvent(new Event('blur', { bubbles: true }));
          
          // 触发焦点事件
          contentInput.focus();
          contentInput.dispatchEvent(new Event('focus', { bubbles: true }));
          
          console.log('✅ 内容填写完成:', fullContent);
          return true;
          
        } else if (contentInput.tagName === 'TEXTAREA') {
          // 使用真人打字方式填写textarea
          await this.humanTyping(contentInput, fullContent, '内容');
          
          contentInput.focus();
          
          console.log('✅ 内容填写完成:', fullContent);
          return true;
        }
        
      } catch (error) {
        console.error('❌ 内容填写失败:', error);
        return false;
      }
    }
    
    console.warn('❌ 未找到内容输入框，尝试手动查找...');
    
    // 手动查找策略：遍历所有可编辑元素
    const allEditable = document.querySelectorAll('div[contenteditable="true"], textarea');
    console.log(`🔍 页面共有 ${allEditable.length} 个可编辑元素`);
    
    for (let i = 0; i < allEditable.length; i++) {
      const element = allEditable[i];
      const placeholder = element.getAttribute('data-placeholder') || element.placeholder || '';
      const className = element.className || '';
      const tagName = element.tagName;
      
      console.log(`🔍 检查元素 ${i + 1}: ${tagName}, placeholder="${placeholder}", class="${className}"`);
      
      // 如果找到编辑器元素
      if (className.includes('ql-editor') || className.includes('ProseMirror') || 
          className.includes('tiptap') || placeholder.includes('描述') || 
          placeholder.includes('正文') || className.includes('editor')) {
        console.log('🎯 尝试使用备选内容输入框:', element);
        
        try {
          // 模拟真人操作延时
          await this.humanDelayWait('使用备选输入框填写内容前');
          
          // 构建完整的内容（包括标签），确保在一行显示
          let fullContent = this.contentData.content.replace(/\n/g, ' ').replace(/\r/g, ' ');
          
          // 如果有标签，添加到内容末尾，使用空格连接确保在同一行
          if (this.contentData.tags && this.contentData.tags.trim()) {
            const tags = this.contentData.tags.split(',').map(tag => tag.trim()).filter(tag => tag);
            if (tags.length > 0) {
              // 使用空格分隔标签，确保所有内容在一行
              fullContent += ' ' + tags.map(tag => `#${tag}`).join(' ');
            }
          }
          
          if (element.contentEditable === 'true') {
            // 检查是否是ProseMirror编辑器
            if (element.classList.contains('ProseMirror') || element.classList.contains('tiptap')) {
              console.log('🎯 备选方案：识别为ProseMirror编辑器');
              
              element.focus();
              await new Promise(resolve => setTimeout(resolve, 200));
              
              try {
                document.execCommand('selectAll', false, null);
                document.execCommand('delete', false, null);
                document.execCommand('insertText', false, fullContent);
              } catch (error) {
                const pElement = element.querySelector('p');
                if (pElement) {
                  pElement.textContent = fullContent;
                  pElement.classList.remove('is-empty', 'is-editor-empty');
                } else {
                  element.innerHTML = `<p>${fullContent}</p>`;
                }
                element.dispatchEvent(new Event('input', { bubbles: true }));
              }
            } else {
              // 使用真人打字方式
              await this.humanTyping(element, fullContent, '内容');
            }
            
            console.log('✅ 使用备选输入框填写内容成功');
            return true;
            
          } else if (element.tagName === 'TEXTAREA') {
            // 使用真人打字方式
            await this.humanTyping(element, fullContent, '内容');
            
            console.log('✅ 使用备选textarea填写内容成功');
            return true;
          }
          
        } catch (error) {
          console.error('❌ 备选输入框填写失败:', error);
        }
      }
    }
    
    console.warn('❌ 所有内容填写策略都失败了');
    return false;
  }

  // 查找上传区域
  async findUploadArea() {
    console.log('🔍 查找上传区域...');
    
    // 等待页面加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 查找上传区域
    const uploadArea = document.querySelector('div[class*="upload"], div[class*="file"], div[class*="media"]') ||
                      document.querySelector('.upload-area') ||
                      document.querySelector('[class*="upload"]');
    
    if (uploadArea) {
      console.log('✅ 找到上传区域');
      
      // 查找上传按钮
      const uploadButton = uploadArea.querySelector('.upload-button') || 
                          uploadArea.querySelector('button') ||
                          uploadArea.querySelector('input[type="file"]');
      
      if (uploadButton) {
        console.log('✅ 找到上传按钮:', uploadButton.textContent || uploadButton.type);
        
        // 如果找到的是文件输入框，返回成功但不执行上传
        if (uploadButton.type === 'file') {
          console.log('📁 找到文件输入框，准备上传...');
          return { success: true, area: uploadArea, fileInput: uploadButton };
        } else {
          // 如果是按钮，尝试点击触发文件选择
          console.log('🖱️ 找到上传按钮，尝试点击...');
          uploadButton.click();
          
          // 等待文件选择对话框出现
          await new Promise(resolve => setTimeout(resolve, 1000));
          
          // 查找新出现的文件输入框
          const fileInput = document.querySelector('input[type="file"]');
          if (fileInput) {
            console.log('📁 找到文件输入框，准备上传...');
            return { success: true, area: uploadArea, fileInput: fileInput };
          }
        }
      }
      
      return { success: false, area: uploadArea };
    }
    
    console.warn('❌ 未找到上传区域');
    return { success: false, area: null };
  }

  // 检测已上传的内容
  async detectUploadedContent() {
    console.log('🔍 检测已上传内容...');
    
    const contentElements = [];
    const imageElements = [];
    const videoElements = [];
    
    try {
      // 查找图片内容
      const images = document.querySelectorAll('img[src*="xhscdn"], img[src*="xiaohongshu"], img[src*="cdn"]');
      images.forEach(img => {
        // 过滤掉头像、图标等无关图片
        if (img.alt && !img.alt.includes('头像') && !img.alt.includes('icon') && 
            img.width > 100 && img.height > 100) {
          imageElements.push(img);
          console.log('📷 找到图片:', img.src, img.alt);
        }
      });
      
      // 查找视频内容
      const videos = document.querySelectorAll('video[src*="xhscdn"], video[src*="xiaohongshu"], video[src*="cdn"]');
      videos.forEach(video => {
        videoElements.push(video);
        console.log('🎥 找到视频:', video.src);
      });
      
      // 检查是否有视频上传成功的提示
      const videoUploadSuccess = this.checkVideoUploadSuccess();
      if (videoUploadSuccess) {
        console.log('✅ 检测到视频上传成功状态');
        // 即使没有video元素，也认为有视频内容
        if (videoElements.length === 0) {
          console.log('📹 视频已上传成功，但尚未生成video元素');
        }
      }
      
      // 查找内容容器
      const contentContainers = document.querySelectorAll('div[class*="uploaded"], div[class*="content"], div[class*="media"]');
      contentContainers.forEach(container => {
        if (container.textContent && container.textContent.length > 10) {
          contentElements.push(container);
          console.log('📦 找到内容容器:', container.className, container.textContent.substring(0, 50));
        }
      });
      
      // 查找"继续编辑"提示
      const editPrompts = document.querySelectorAll('div[class*="progetto-sugger"], div[class*="edit"], div[class*="continue"]');
      editPrompts.forEach(prompt => {
        if (prompt.textContent && prompt.textContent.includes('继续编辑')) {
          contentElements.push(prompt);
          console.log('✏️ 找到编辑提示:', prompt.textContent);
        }
      });
      
      const hasVideos = videoElements.length > 0 || videoUploadSuccess;
      console.log(`🔍 检测结果: ${imageElements.length} 张图片, ${videoElements.length} 个视频元素, ${hasVideos ? '视频上传成功' : '无视频'}, ${contentElements.length} 个内容容器`);
      
      return {
        imageElements,
        videoElements,
        contentElements,
        hasImages: imageElements.length > 0,
        hasVideos: hasVideos,
        hasContent: contentElements.length > 0
      };
      
    } catch (error) {
      console.error('检测已上传内容失败:', error);
      return {
        imageElements: [],
        videoElements: [],
        contentElements: [],
        hasImages: false,
        hasVideos: false,
        hasContent: false
      };
    }
  }

  // 处理已上传内容
  async handleUploadedContent(uploadedContent) {
    console.log('🔄 处理已上传内容...');
    
    if (!uploadedContent || (!uploadedContent.hasImages && !uploadedContent.hasVideos && !uploadedContent.hasContent)) {
      console.log('📭 没有检测到已上传内容');
      return false;
    }
    
    // 检查内容类型是否匹配
    const contentType = this.contentData.content_type;
    console.log('🎯 目标内容类型:', contentType);
    
    let typeMatches = false;
    
    if (contentType === '图文' && uploadedContent.hasImages) {
      console.log('✅ 图文类型匹配已上传图片');
      typeMatches = true;
    } else if (contentType === '视频' && uploadedContent.hasVideos) {
      console.log('✅ 视频类型匹配已上传视频');
      typeMatches = true;
    } else if (uploadedContent.hasContent) {
      console.log('✅ 检测到内容容器，可能包含匹配的内容');
      typeMatches = true;
    }
    
    // 即使有现有内容，也继续处理新的内容填写
    // 因为用户可能想要更新内容或添加新的图片/视频
    console.log('ℹ️ 继续处理内容填写，不依赖现有内容');
    return false; // 返回 false 让系统继续执行内容填写
  }

  // 智能查找元素
  findElement(selectors) {
    for (const selector of selectors) {
      try {
        if (selector.includes(':contains(')) {
          // 处理 :contains 选择器
          const text = selector.match(/:contains\("([^"]+)"\)/)[1];
          const elements = document.querySelectorAll(selector.replace(/:contains\("[^"]+"\)/, ''));
          for (const element of elements) {
            if (element.textContent.includes(text)) {
              return element;
            }
          }
        } else {
          const element = document.querySelector(selector);
          if (element) return element;
        }
      } catch (error) {
        console.warn('选择器查找失败:', selector, error);
      }
    }
    return null;
  }

  // 带重试的元素查找
  async findElementWithRetry(selectors, elementType) {
    console.log(`🔍 查找${elementType}元素，使用 ${selectors.length} 个选择器...`);
    
    for (let attempt = 1; attempt <= 3; attempt++) {
      console.log(`🔄 第 ${attempt} 次尝试查找${elementType}...`);
      
      for (const selector of selectors) {
        try {
          const element = document.querySelector(selector);
          if (element) {
            console.log(`✅ 通过选择器找到${elementType}:`, selector);
            return element;
          }
        } catch (error) {
          console.warn(`⚠️ 选择器查找失败:`, selector, error);
        }
      }
      
      if (attempt < 3) {
        console.log(`⏳ 第 ${attempt} 次查找失败，等待后重试...`);
        // 等待一段时间后重试，但不递归调用
        await new Promise(resolve => setTimeout(resolve, attempt * 1000));
      }
    }
    
    console.warn(`❌ 所有选择器都无法找到${elementType}元素`);
    return null;
  }

  // 设置发布时间
  async setPublishTime() {
    console.log('🕐 开始设置发布时间...');
    
    // 检查是否需要设置定时发布
    if (!this.contentData.publish_time) {
      console.log('✅ 使用立即发布，无需设置时间');
      return true;
    }
    
    try {
      // 等待页面加载
      await new Promise(resolve => setTimeout(resolve, 2000));
      
      // 滚动到页面底部，因为发布时间设置在底部
      console.log('📜 开始滚动到页面底部查找发布时间选项...');
      
      // 多种滚动方式确保滚动到底部
      const scrollHeight = Math.max(
        document.body.scrollHeight,
        document.documentElement.scrollHeight,
        document.body.offsetHeight,
        document.documentElement.offsetHeight,
        document.body.clientHeight,
        document.documentElement.clientHeight
      );
      
      console.log(`📏 页面高度: ${scrollHeight}, 当前滚动位置: ${window.pageYOffset}`);
      
      // 方法1: 使用window.scrollTo
      window.scrollTo({
        top: scrollHeight,
        left: 0,
        behavior: 'smooth'
      });
      
      await new Promise(resolve => setTimeout(resolve, 1000));
      
      // 方法2: 如果还没到底部，使用强制滚动
      if (window.pageYOffset < scrollHeight - window.innerHeight - 100) {
        console.log('⚠️ 第一次滚动未到底部，尝试强制滚动');
        window.scrollTo(0, scrollHeight);
        document.documentElement.scrollTop = scrollHeight;
        document.body.scrollTop = scrollHeight;
      }
      
      await new Promise(resolve => setTimeout(resolve, 1000));
      console.log(`📍 滚动后位置: ${window.pageYOffset}, 页面高度: ${scrollHeight}`);
      
      // 查找发布时间选项区域 - 使用更广泛的策略
      console.log('🔍 开始查找发布时间选项区域...');
      
      let publishTimeContainer = null;
      
      // 策略1: 直接查找包含单选按钮的容器
      const radioContainers = Array.from(document.querySelectorAll('div')).filter(div => {
        const radios = div.querySelectorAll('input[type="radio"]');
        return radios.length >= 2; // 至少有2个单选按钮（立即发布 + 定时发布）
      });
      
      console.log(`📋 找到 ${radioContainers.length} 个包含单选按钮的容器`);
      
      // 从这些容器中查找包含"发布时间"或相关文本的
      publishTimeContainer = radioContainers.find(container => {
        const text = container.textContent || '';
        return text.includes('发布时间') || text.includes('立即发布') || text.includes('定时发布');
      });
      
      // 策略2: 如果没找到，尝试传统选择器
      if (!publishTimeContainer) {
        console.log('⚠️ 策略1失败，尝试传统选择器...');
        publishTimeContainer = document.querySelector('div[data-v-b0454eec][class*="flexbox"]') ||
                              document.querySelector('div.el-radio-group') ||
                              document.querySelector('[role="radiogroup"]') ||
                              Array.from(document.querySelectorAll('div')).find(div => 
                                div.textContent && div.textContent.includes('发布时间')
                              );
      }
      
      // 策略3: 如果还是没找到，查找页面中所有的单选按钮组
      if (!publishTimeContainer && radioContainers.length > 0) {
        console.log('⚠️ 策略2失败，使用最后的备用方案...');
        // 选择最后一个单选按钮容器（通常发布选项在最后）
        publishTimeContainer = radioContainers[radioContainers.length - 1];
        console.log('🔄 使用最后一个单选按钮容器作为备用方案');
      }
      
      if (!publishTimeContainer) {
        console.warn('❌ 所有策略都未找到发布时间选项区域');
        console.log('📋 调试信息：');
        console.log('单选按钮容器数量:', radioContainers.length);
        console.log('单选按钮容器内容:', radioContainers.map((container, index) => ({
          index,
          text: container.textContent.substring(0, 100),
          radioCount: container.querySelectorAll('input[type="radio"]').length
        })));
        
        console.log('页面所有包含"时间"或"发布"的元素:');
        const timeRelatedElements = Array.from(document.querySelectorAll('*')).filter(el => {
          const text = el.textContent || '';
          return (text.includes('时间') || text.includes('发布')) && text.length < 200;
        });
        console.log(timeRelatedElements.slice(0, 15).map(el => ({
          tagName: el.tagName,
          className: el.className,
          text: el.textContent.substring(0, 50)
        })));
        
        return false;
      }
      
      console.log('✅ 找到发布时间选项区域');
      
      // 查找"定时发布"选项 - 扩展查找策略
      let scheduledRadio = null;
      
      // 策略1: 通过value查找
      scheduledRadio = publishTimeContainer.querySelector('input[type="radio"][value="1"]');
      
      if (!scheduledRadio) {
        // 策略2: 通过标签文本查找
        const radioButtons = publishTimeContainer.querySelectorAll('input[type="radio"]');
        for (const radio of radioButtons) {
          const label = radio.parentElement.querySelector('.el-radio__label') ||
                       radio.nextElementSibling ||
                       radio.parentElement.textContent;
          
          if (label && (typeof label === 'string' ? label : label.textContent || '').includes('定时发布')) {
            scheduledRadio = radio;
            break;
          }
        }
      }
      
      if (!scheduledRadio) {
        // 策略3: 查找第二个单选按钮（通常立即发布是第一个，定时发布是第二个）
        const allRadios = publishTimeContainer.querySelectorAll('input[type="radio"]');
        if (allRadios.length >= 2) {
          scheduledRadio = allRadios[1]; // 第二个通常是定时发布
          console.log('⚠️ 使用备用策略：选择第二个单选按钮作为定时发布');
        }
      }
      
      if (!scheduledRadio) {
        console.warn('❌ 未找到定时发布选项');
        // 调试信息：列出找到的所有单选按钮
        const allRadios = publishTimeContainer.querySelectorAll('input[type="radio"]');
        console.log('📋 调试：找到的所有单选按钮:', Array.from(allRadios).map((radio, index) => ({
          index,
          value: radio.value,
          checked: radio.checked,
          labelText: radio.parentElement.textContent.trim()
        })));
        return false;
      }
      
      console.log('✅ 找到定时发布选项');
      
      // 模拟真人操作延时
      await this.humanDelayWait('点击定时发布选项前');
      
      // 点击定时发布选项
      scheduledRadio.click();
      console.log('✅ 已点击定时发布选项');
      
      // 等待时间选择器出现 - 增加等待时间
      console.log('⏳ 等待时间选择器出现...');
      await new Promise(resolve => setTimeout(resolve, 2000));
      
      // 查找时间输入框 - 扩展选择器
      let timeInput = null;
      const timeInputSelectors = [
        'input[type="datetime-local"]',
        'input[placeholder*="时间"]',
        'input[placeholder*="日期"]',
        'input[placeholder*="选择时间"]',
        'input[placeholder*="选择日期"]',
        '.el-date-editor input',
        '.time-picker input',
        '.el-input__inner',
        'input[class*="time"]',
        'input[class*="date"]'
      ];
      
      for (const selector of timeInputSelectors) {
        timeInput = document.querySelector(selector);
        if (timeInput) {
          console.log(`✅ 通过选择器 "${selector}" 找到时间输入框`);
          break;
        }
      }
      
      if (!timeInput) {
        console.warn('❌ 未找到时间输入框');
        console.log('📋 调试：查找所有input元素');
        const allInputs = document.querySelectorAll('input');
        console.log('页面所有input:', Array.from(allInputs).map(input => ({
          type: input.type,
          placeholder: input.placeholder,
          className: input.className,
          style: input.style.display
        })));
        return false;
      }
      
      console.log('✅ 找到时间输入框');
      
      // 设置发布时间
      const publishTime = this.contentData.publish_time;
      let timeValue = publishTime;
      
      // 模拟真人操作延时
      await this.humanDelayWait('设置发布时间前');
      
      // 聚焦并清空现有值
      timeInput.focus();

      await new Promise(resolve => setTimeout(resolve, 100));
      
      timeInput.value = '';
      
      // 设置时间值
      if (timeInput.type === 'datetime-local') {
        // 直接设置值
        timeInput.value = timeValue;
      } else {
        // 使用真人打字方式填入时间
        await this.humanTyping(timeInput, timeValue, '发布时间');
      }
      
      // 触发事件确保时间设置生效
      timeInput.dispatchEvent(new Event('change', { bubbles: true }));
      timeInput.dispatchEvent(new Event('input', { bubbles: true }));
      timeInput.dispatchEvent(new Event('blur', { bubbles: true }));
      
      // 🔧 关键：关闭时间选择器弹窗
      await this.closeDateTimePicker(timeInput);
      
      console.log(`✅ 已设置发布时间: ${timeValue}`);
      
      
      return true;
      
    } catch (error) {
      console.error('❌ 设置发布时间失败:', error);
      return false;
    }
  }

  // 自动点击发布按钮
  async clickPublishButton() {
    console.log('🚀 尝试自动点击发布按钮...');
    
    // 等待一下让页面完全加载
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 使用更精确的选择器查找发布按钮
    const publishSelectors = [
      // 精确选择器 - 基于真实的HTML结构
      'button.publishBtn',
      'button[class*="publishBtn"]',
      'button[class*="publish"]',
      'button[class*="d-button"][class*="red"]',
      
      // 通用选择器（作为备选）
      'button',
      'div[role="button"]',
      '.btn',
      '[class*="btn"]'
    ];
    
    console.log('🔍 使用精确选择器查找发布按钮...');
    
    // 首先尝试精确选择器
    for (const selector of publishSelectors) {
      try {
        const elements = document.querySelectorAll(selector);
        for (const element of elements) {
          const buttonText = element.textContent || element.innerText || '';
          const className = element.className || '';
          
          console.log(`🔍 检查元素: "${buttonText}", class="${className}"`);
          
          // 检查是否是发布按钮
          if (buttonText.includes('发布') || 
              className.includes('publishBtn') || 
              className.includes('publish') ||
              (className.includes('d-button') && className.includes('red'))) {
            console.log(`✅ 找到发布按钮: "${buttonText}"`);
            
            try {
              // 模拟真人操作延时
              await this.humanDelayWait('点击发布按钮前');
              
              element.click();
              console.log('✅ 已点击发布按钮');
              return true;
            } catch (error) {
              console.error('❌ 点击发布按钮失败:', error);
            }
          }
        }
      } catch (error) {
        console.warn(`⚠️ 选择器查找失败:`, selector, error);
      }
    }
    
    console.warn('❌ 未找到发布按钮');
    return false;
  }

  // 调试功能：显示页面上的所有输入元素
  async debugPageElements() {
    console.log('🔍 开始调试页面元素...');
    
    // 创建调试面板
    const debugPanel = document.createElement('div');
    debugPanel.style.cssText = `
      position: fixed;
      top: 20px;
      left: 20px;
      background: rgba(0, 0, 0, 0.9);
      color: white;
      padding: 20px;
      border-radius: 8px;
      z-index: 10000;
      font-family: monospace;
      font-size: 12px;
      max-width: 500px;
      max-height: 400px;
      overflow-y: auto;
      border: 2px solid #ff6b6b;
    `;
    
    let debugInfo = '<h3 style="color: #ff6b6b; margin: 0 0 15px 0;">🔍 页面元素调试信息</h3>';
    
    // 查找所有输入元素
    const allInputs = document.querySelectorAll('input, textarea, [contenteditable="true"]');
    debugInfo += `<p><strong>📝 找到 ${allInputs.length} 个输入元素:</strong></p>`;
    
    for (let i = 0; i < allInputs.length; i++) {
      const input = allInputs[i];
      const tagName = input.tagName;
      const type = input.type || 'N/A';
      const placeholder = input.placeholder || 'N/A';
      const className = input.className || 'N/A';
      const id = input.id || 'N/A';
      const name = input.name || 'N/A';
      const value = input.value || 'N/A';
      const rows = input.rows || 'N/A';
      const contentEditable = input.contentEditable || 'N/A';
      
      debugInfo += `
        <div style="border: 1px solid #444; margin: 5px 0; padding: 10px; background: rgba(255, 255, 255, 0.1);">
          <strong>元素 ${i + 1}:</strong><br>
          <span style="color: #4ecdc4;">标签:</span> ${tagName}<br>
          <span style="color: #4ecdc4;">类型:</span> ${type}<br>
          <span style="color: #4ecdc4;">占位符:</span> ${placeholder}<br>
          <span style="color: #4ecdc4;">类名:</span> ${className}<br>
          <span style="color: #4ecdc4;">ID:</span> ${id}<br>
          <span style="color: #4ecdc4;">名称:</span> ${name}<br>
          <span style="color: #4ecdc4;">值:</span> ${value}<br>
          <span style="color: #4ecdc4;">行数:</span> ${rows}<br>
          <span style="color: #4ecdc4;">可编辑:</span> ${contentEditable}<br>
          <span style="color: #4ecdc4;">位置:</span> ${input.offsetTop}, ${input.offsetLeft}
        </div>
      `;
    }
    
    // 查找可能的标题和内容区域
    debugInfo += '<p><strong>🎯 可能的标题区域:</strong></p>';
    const titleCandidates = document.querySelectorAll('div, span, label');
    let titleCount = 0;
    for (const candidate of titleCandidates) {
      const text = candidate.textContent || '';
      if (text.includes('标题') && titleCount < 5) {
        debugInfo += `<div style="color: #ffd93d; margin: 2px 0;">${candidate.tagName}: "${text}"</div>`;
        titleCount++;
      }
    }
    
    debugInfo += '<p><strong>📝 可能的内容区域:</strong></p>';
    const contentCandidates = document.querySelectorAll('div, span, label');
    let contentCount = 0;
    for (const candidate of contentCandidates) {
      const text = candidate.textContent || '';
      if ((text.includes('内容') || text.includes('描述')) && contentCount < 5) {
        debugInfo += `<div style="color: #6bcf7f; margin: 2px 0;">${candidate.tagName}: "${text}"</div>`;
        contentCount++;
      }
    }
    
    // 添加内容填写测试按钮
    debugInfo += `
      <p><strong>🧪 内容填写测试:</strong></p>
      <button onclick="testContentFilling()" style="
        background: #4ecdc4; 
        color: white; 
        border: none; 
        padding: 8px 16px; 
        border-radius: 4px; 
        cursor: pointer;
        margin: 5px;
      ">测试标题填写</button>
      <button onclick="testContentFilling('content')" style="
        background: #6bcf7f; 
        color: white; 
        border: none; 
        padding: 8px 16px; 
        border-radius: 4px; 
        cursor: pointer;
        margin: 5px;
      ">测试内容填写</button>
      <button onclick="testContentFilling('tags')" style="
        background: #ffd93d; 
        color: white; 
        border: none; 
        padding: 8px 16px; 
        border-radius: 4px; 
        cursor: pointer;
        margin: 5px;
      ">测试标签填写</button>
      <button onclick="testImageUpload()" style="
        background: #ff6b6b; 
        color: white; 
        border: none; 
        padding: 8px 16px; 
        border-radius: 4px; 
        cursor: pointer;
        margin: 5px;
      ">测试图片上传</button>
    `;
    
    // 添加关闭按钮
    debugInfo += `
      <div style="text-align: center; margin-top: 15px;">
        <button onclick="this.parentElement.parentElement.remove()" style="
          background: #ff6b6b; 
          color: white; 
          border: none; 
          padding: 8px 16px; 
          border-radius: 4px; 
          cursor: pointer;
        ">关闭调试面板</button>
      </div>
    `;
    
    debugPanel.innerHTML = debugInfo;
    document.body.appendChild(debugPanel);
    
    // 注入测试函数
    window.testContentFilling = function(type = 'title') {
      console.log(`🧪 测试${type}填写...`);
      
      let testValue = '';
      let selectors = [];
      
      switch(type) {
        case 'title':
          testValue = '测试标题_' + Date.now();
          selectors = [
            'input[placeholder*="标题"]',
            'textarea[placeholder*="标题"]',
            'input[type="text"]',
            'textarea'
          ];
          break;
        case 'content':
          testValue = '测试内容_' + Date.now();
          selectors = [
            'textarea[placeholder*="内容"]',
            'textarea[placeholder*="描述"]',
            'textarea[rows]',
            'div[contenteditable="true"]'
          ];
          break;
        case 'tags':
          testValue = '测试标签_' + Date.now();
          selectors = [
            'input[placeholder*="标签"]',
            'input[placeholder*="话题"]',
            'input[type="text"]'
          ];
          break;
      }
      
      for (const selector of selectors) {
        try {
          const element = document.querySelector(selector);
          if (element) {
            console.log(`✅ 找到元素:`, selector, element);
            
            if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
              element.value = testValue;
              element.dispatchEvent(new Event('input', { bubbles: true }));
              element.dispatchEvent(new Event('change', { bubbles: true }));
            } else if (element.contentEditable === 'true') {
              element.innerHTML = testValue;
              element.dispatchEvent(new Event('input', { bubbles: true }));
            }
            
            console.log(`✅ ${type}测试填写成功:`, testValue);
            alert(`${type}测试填写成功: ${testValue}`);
            return;
          }
        } catch (error) {
          console.error(`❌ ${type}测试填写失败:`, error);
        }
      }
      
      console.warn(`❌ 未找到可用的${type}输入框`);
      alert(`未找到可用的${type}输入框`);
    };

    // 注入图片上传测试函数
    window.testImageUpload = function() {
      console.log('🧪 测试图片上传...');
      
      // 查找上传按钮
      const uploadButtonSelectors = [
        'button:contains("上传图片")',
        'button:contains("上传")',
        'div:contains("上传图片")',
        'div:contains("上传")',
        'button[class*="upload"]',
        'div[class*="upload"]'
      ];
      
      for (const selector of uploadButtonSelectors) {
        try {
          const element = document.querySelector(selector);
          if (element) {
            console.log('✅ 找到上传按钮:', selector, element);
            element.click();
            console.log('✅ 已点击上传按钮');
            alert('✅ 已点击上传按钮，请选择图片文件');
            return;
          }
        } catch (error) {
          console.error('❌ 选择器错误:', error);
        }
      }
      
      // 手动查找包含"上传"文本的元素
      const allElements = document.querySelectorAll('button, div, span');
      for (const element of allElements) {
        if (element.textContent && element.textContent.includes('上传')) {
          console.log('✅ 手动找到上传按钮:', element.tagName, element.className, element.textContent);
          element.click();
          console.log('✅ 已点击上传按钮');
          alert('✅ 已点击上传按钮，请选择图片文件');
          return;
        }
      }
      
      console.warn('❌ 未找到上传按钮');
      alert('❌ 未找到上传按钮');
    };
    
    console.log('🔍 调试面板已创建，显示页面元素信息和测试按钮');
    return debugPanel;
  }

  // 查找编辑按钮
  findEditButton() {
    const editSelectors = [
      'button:contains("继续编辑")',
      'div:contains("继续编辑")',
      'span:contains("继续编辑")',
      'a:contains("继续编辑")',
      'button[class*="edit"]',
      'div[class*="edit"]',
      'span[class*="edit"]'
    ];
    
    for (const selector of editSelectors) {
      try {
        const element = document.querySelector(selector);
        if (element) {
          console.log('✅ 找到编辑按钮:', selector);
          return element;
        }
      } catch (error) {
        // 忽略选择器错误
      }
    }
    
    // 手动查找包含"继续编辑"文本的元素
    const allElements = document.querySelectorAll('*');
    for (const element of allElements) {
      if (element.textContent && element.textContent.includes('继续编辑')) {
        console.log('✅ 手动找到编辑按钮:', element.tagName, element.className);
        return element;
      }
    }
    
    console.log('❌ 未找到编辑按钮');
    return null;
  }

  // 查找文件输入框
  findFileInput() {
    console.log('🔍 查找文件输入框...');
    
    // 使用多种策略查找文件输入框
    const fileInputSelectors = [
      'input[type="file"]',
      'input[accept*="image"]',
      'input[accept*="video"]',
      'input[class*="file"]',
      'input[class*="upload"]',
      'input[name*="file"]',
      'input[name*="upload"]'
    ];
    
    for (const selector of fileInputSelectors) {
      try {
        const fileInput = document.querySelector(selector);
        if (fileInput) {
          console.log('✅ 找到文件输入框:', selector);
          return fileInput;
        }
      } catch (error) {
        console.warn(`⚠️ 选择器查找失败:`, selector, error);
      }
    }
    
    // 如果没有找到，尝试遍历所有input元素
    const allInputs = document.querySelectorAll('input');
    console.log(`🔍 页面共有 ${allInputs.length} 个input元素`);
    
    for (let i = 0; i < allInputs.length; i++) {
      const input = allInputs[i];
      const type = input.type || '';
      const className = input.className || '';
      const name = input.name || '';
      
      console.log(`🔍 检查input ${i + 1}: type="${type}", class="${className}", name="${name}"`);
      
      // 如果找到文件类型的input
      if (type === 'file' || className.includes('file') || className.includes('upload') || 
          name.includes('file') || name.includes('upload')) {
        console.log('🎯 找到可能的文件输入框:', input);
        return input;
      }
    }
    
    console.warn('❌ 未找到文件输入框');
    return null;
  }

  // 处理图片上传
  async handleImageUpload() {
    console.log('📁 开始处理图片上传...');
    
    try {
      // 检查是否有文件地址
      if (!this.contentData.file_url) {
        console.log('📭 没有文件地址');
        return false;
      }
      
      console.log('📁 检测到文件地址:', this.contentData.file_url);
      
      // 查找上传区域
      const uploadAreaResult = await this.findUploadArea();
      if (!uploadAreaResult.success) {
        console.log('❌ 未找到上传区域');
        return false;
      }
      
      const uploadArea = uploadAreaResult.area;
      console.log('✅ 找到上传区域:', uploadArea);
      
      // 优先使用findUploadArea返回的文件输入框
      let fileInput = uploadAreaResult.fileInput;
      
      // 如果没有找到，使用备用方法查找
      if (!fileInput) {
        fileInput = this.findFileInput();
        if (!fileInput) {
          console.log('❌ 未找到文件输入框');
          return false;
        }
      }
      
      console.log('✅ 找到文件输入框:', fileInput);
      
      // 只执行一次上传
      const uploadResult = await this.uploadFilesToInput(fileInput);
      
      if (uploadResult) {
        console.log('✅ 文件上传成功');
        return true;
      } else {
        console.log('❌ 文件上传失败');
        return false;
      }
      
    } catch (error) {
      console.error('❌ 图片上传处理失败:', error);
      return false;
    }
  }

  // 上传文件到输入框
  async uploadFilesToInput(fileInput) {
    console.log('📤 开始上传文件到输入框...');
    
    // 检查是否已经尝试过上传
    if (this.uploadAttempted) {
      console.log('⚠️ 已经尝试过上传，跳过重复上传');
      return true; // 返回true表示上传已完成
    }
    
    try {
      // 检查是否有文件地址
      if (!this.contentData.file_url) {
        console.log('📭 没有文件地址');
        return false;
      }
      
      // 标记为已尝试上传
      this.uploadAttempted = true;
      console.log('📁 准备从URL创建文件:', this.contentData.file_url);
      
      // 从URL创建文件对象
      try {
        const file = await this.createFileFromUrl(this.contentData.file_url);
        if (!file) {
          console.log('❌ 无法从URL创建文件');
          return false;
        }
        
        // 创建 DataTransfer 对象
        const dataTransfer = new DataTransfer();
        dataTransfer.items.add(file);
        
        // 设置文件输入框的值
        fileInput.files = dataTransfer.files;
        
        // 触发 change 事件
        fileInput.dispatchEvent(new Event('change', { bubbles: true }));
        fileInput.dispatchEvent(new Event('input', { bubbles: true }));
        
        console.log('✅ 文件已设置到输入框，等待上传完成...');
        
        // 等待上传完成
        const uploadSuccess = await this.waitForUploadComplete();
        
        if (uploadSuccess) {
          console.log('✅ 文件上传完成');
          return true;
        } else {
          console.log('⏰ 等待上传超时');
          this.uploadAttempted = false; // 重置上传标记，允许重试
          return false;
        }
        
      } catch (error) {
        console.error('❌ 从URL创建文件失败:', error);
        this.uploadAttempted = false; // 重置上传标记，允许重试
        return false;
      }
      
    } catch (error) {
      console.error('❌ 文件上传失败:', error);
      this.uploadAttempted = false; // 重置上传标记，允许重试
      return false;
    }
  }

  // 从URL创建文件对象
  async createFileFromUrl(url) {
    try {
      console.log('🔄 从URL创建文件对象:', url);
      
      // 从URL获取文件名和类型
      const fileName = this.getFileNameFromUrl(url);
      const fileType = this.getFileTypeFromUrl(fileName);
      
      console.log('📁 文件信息:', fileName, fileType);
      
      // 获取文件内容
      const response = await window.electronAPI.fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      
      // 获取文件内容为 Blob
      const blob = await response.blob();
      
      // 创建 File 对象
      const file = new File([blob], fileName, { 
        type: fileType,
        lastModified: Date.now()
      });
      
      console.log('✅ 文件对象创建成功:', file.name, file.type, file.size);
      return file;
      
    } catch (error) {
      console.error('❌ 从URL创建文件失败:', error);
      
      // 如果网络获取失败，返回null
      console.log('❌ 无法从URL获取文件，请检查网络连接或URL是否有效');
      return null;
    }
  }

  // 从URL获取文件名
  getFileNameFromUrl(url) {
    try {
      const urlObj = new URL(url);
      const pathname = urlObj.pathname;
      const fileName = pathname.split('/').pop() || 'file';
      
      // 如果没有扩展名，根据内容类型添加
      if (!fileName.includes('.')) {
        if (this.contentData.content_type === '图文') {
          return fileName + '.jpg';
        } else if (this.contentData.content_type === '视频') {
          return fileName + '.mp4';
        }
      }
      
      return fileName;
    } catch (error) {
      console.log('⚠️ 解析URL失败，使用默认文件名');
      return 'file.jpg';
    }
  }

  // 从文件名获取文件类型
  getFileTypeFromUrl(fileName) {
    const extension = fileName.toLowerCase().split('.').pop();
    
    switch (extension) {
      case 'jpg':
      case 'jpeg':
        return 'image/jpeg';
      case 'png':
        return 'image/png';
      case 'gif':
        return 'image/gif';
      case 'webp':
        return 'image/webp';
      case 'mp4':
        return 'video/mp4';
      case 'avi':
        return 'video/x-msvideo';
      case 'mov':
        return 'video/quicktime';
      case 'webm':
        return 'video/webm';
      default:
        // 根据内容类型返回默认类型
        if (this.contentData.content_type === '图文') {
          return 'image/jpeg';
        } else if (this.contentData.content_type === '视频') {
          return 'video/mp4';
        }
        return 'application/octet-stream';
    }
  }

  // 等待上传完成
  async waitForUploadComplete() {
    console.log('⏳ 等待文件上传完成...');
    
    // 增加等待时间，上传可能需要更长时间
    const maxWaitTime = 120000; // 增加到2分钟
    const checkInterval = 1000; // 每1秒检查一次
    const startTime = Date.now();
    
    while (Date.now() - startTime < maxWaitTime) {
      // 检查是否有上传完成的图片
      const uploadedImages = document.querySelectorAll('img[src*="xhscdn"], img[src*="xiaohongshu"], img[src*="cdn"]');
      const uploadedVideos = document.querySelectorAll('video[src*="xhscdn"], video[src*="xiaohongshu"], video[src*="cdn"]');
      
      // 检查是否有视频上传成功的提示（基于你提供的HTML结构）
      const videoUploadSuccess = this.checkVideoUploadSuccess();
      
      if (uploadedImages.length > 0 || uploadedVideos.length > 0 || videoUploadSuccess) {
        console.log('✅ 检测到上传完成的文件');
        
        // 上传完成后，等待一段时间让页面稳定
        console.log('⏳ 上传完成，等待页面稳定...');
        await new Promise(resolve => setTimeout(resolve, 4000)); // 等待4秒
        
        console.log('✅ 页面已稳定，可以继续下一步');
        return true;
      }
      
      // 等待2秒后再次检查
      await new Promise(resolve => setTimeout(resolve, checkInterval));
    }
    
    console.log('⏰ 等待上传超时');
    return false;
  }

  // 检查视频上传是否成功
  checkVideoUploadSuccess() {
    try {
      // 查找包含"上传成功"文本的元素
      const uploadSuccessElements = document.querySelectorAll('div, span, p');
      
      for (const element of uploadSuccessElements) {
        const text = element.textContent || element.innerText || '';
        if (text.includes('上传成功')) {
          console.log('✅ 检测到视频上传成功提示:', text);
          
          // 检查是否包含视频相关信息（大小、时长等）
          const parentElement = element.closest('div[class*="stage"]') || element.parentElement;
          if (parentElement) {
            const parentText = parentElement.textContent || parentElement.innerText || '';
            if (parentText.includes('视频大小') || parentText.includes('视频时长') || parentText.includes('MB') || parentText.includes('s')) {
              console.log('✅ 确认是视频上传成功:', parentText);
              return true;
            }
          }
        }
      }
      
      // 也可以直接查找包含视频信息的元素
      const videoInfoElements = document.querySelectorAll('div[class*="stage"]');
      for (const element of videoInfoElements) {
        const text = element.textContent || element.innerText || '';
        if (text.includes('上传成功') && (text.includes('视频大小') || text.includes('视频时长'))) {
          console.log('✅ 通过stage元素检测到视频上传成功:', text);
          return true;
        }
      }
      
      return false;
    } catch (error) {
      console.error('❌ 检查视频上传状态失败:', error);
      return false;
    }
  }

  // 执行完整的发布流程
  async execute() {
    console.log('🚀 开始小红书自动化发布流程...');
    console.log('内容类型:', this.contentData.content_type);
    console.log('标题:', this.contentData.title);
    console.log('内容:', this.contentData.content);
    console.log('标签:', this.contentData.tags);
    
    try {
      // 等待页面加载
      await this.waitForPageLoad();
      
      // 第一步：点击发布笔记（如果需要）
      await this.clickPublishNote();
      
      // 步骤间延时
      await this.humanDelayWait('第一步完成后');
      
      // 第二步：选择内容类型
      await this.selectContentType();
      
      // 步骤间延时
      await this.humanDelayWait('第二步完成后');
      
      // 第三步：检测已上传内容
      const uploadedContent = await this.detectUploadedContent();
      
      // 第四步：处理已上传内容
      const useExistingContent = await this.handleUploadedContent(uploadedContent);
      
      // 第五步：显示调试信息（开发模式）
      if (process.env.NODE_ENV === 'development') {
        await this.debugPageElements();
      }
      
      // 第六步：先处理图片上传（小红书要求先上传图片）
      const uploadResult = await this.handleImageUpload();
      
      // 第七步：等待图片上传完成后，再填写内容信息
      if (uploadResult || useExistingContent) {
        console.log('📁 图片已就绪，等待页面完全稳定...');
        
        // 额外等待时间，确保上传后的页面状态完全稳定
        await new Promise(resolve => setTimeout(resolve, 4000)); // 等待4秒
        
        // 模拟真人操作延时
        await this.humanDelayWait('开始填写内容前');
        
        console.log('✅ 页面已稳定，开始填写内容...');
        const contentSuccess = await this.fillContentInfo();
        
        // 第八步：自动点击发布按钮
        let publishStatus = 'draft';
        let publishTime = null;
        let errorMessage = null;
        let errorCode = null;
        
        if (contentSuccess >= 2) { // 至少标题和内容填写成功
          console.log('🚀 内容填写完成，开始设置发布选项...');
          
          // 模拟真人操作延时
          await this.humanDelayWait('设置发布选项前');
          
          // 第九步：设置发布时间
          const timeSetResult = await this.setPublishTime();
          if (!timeSetResult && this.contentData.publish_time) {
            console.log('⚠️ 定时发布时间设置失败，但继续发布流程');
          }
          
          // 模拟真人操作延时
          await this.humanDelayWait('点击发布按钮前');
          
          const publishClicked = await this.clickPublishButton();
          
          if (publishClicked) {
            console.log('✅ 发布按钮已点击，等待发布完成...');
            // 等待发布完成
            await new Promise(resolve => setTimeout(resolve, 5000));
            
            // 检测是否发布失败（检查页面上的错误信息）
            // const publishError = await this.detectPublishError();
            const publishError = false;
            if (publishError) {
              publishStatus = 'failed';
              errorMessage = publishError.message;
              errorCode = publishError.code;
              console.log('❌ 发布失败，错误信息:', errorMessage, '错误代码:', errorCode);
            } else {
              // 如果发布按钮点击成功且没有错误，标记为已发布
              publishStatus = 'published';
              publishTime = this.contentData.publish_time ? this.contentData.publish_time : new Date().toLocaleString();
              console.log('✅ 内容已发布，状态更新为:', publishStatus);
            }
          } else {
            console.log('⚠️ 发布按钮点击失败，状态保持为草稿');
          }
        }
        
        // 获取上传区域用于完成提示
        const uploadAreaResult = await this.findUploadArea();
        const uploadArea = uploadAreaResult.area;
        
        // 显示完成提示
        this.showCompletionNotification(contentSuccess, uploadArea, uploadedContent, useExistingContent, uploadResult);
        
        // 保存发布记录到数据库
        console.log('💾 准备保存发布记录，状态:', publishStatus);
        
        try {
          // 构建完整的记录数据，使用传入的 record_id 来更新现有记录
          const recordData = {
            id: this.contentData.id, // 使用传入的记录ID来更新
            status: publishStatus,
            publish_time: publishTime,
            error_message: errorMessage,
            error_code: errorCode
          };
          
          await this.updatePublishRecordStatus(this.contentData.id, recordData);
          console.log('✅ 发布记录更新成功');
        } catch (error) {
          console.error('❌ 更新发布记录失败:', error);
        }
        
        console.log('🎉 自动化发布流程完成！');
        
        // 检查是否发布成功，如果成功则关闭窗口
        if (publishStatus === 'published') {
          console.log('✅ 发布成功，3秒后自动关闭窗口...');
          setTimeout(() => {
            this.closePublishWindow();
          }, 1000); // 1秒延迟
        }
        
        return {
          contentSuccess,
          hasUploadArea: !!uploadArea,
          hasUploadedContent: uploadedContent.contentElements.length > 0,
          useExistingContent,
          uploadSuccess: uploadResult,
          publishClicked: publishStatus === 'published',
          publishStatus: publishStatus,
          publishTime: publishTime,
          errorMessage: errorMessage,
          errorCode: errorCode,
          message: this.getCompletionMessage(uploadedContent, useExistingContent, contentSuccess, uploadResult)
        };
      } else {
        // 图片上传未完成，提示用户先上传图片
        console.log('📁 需要先上传图片才能继续...');
        const uploadAreaResult = await this.findUploadArea();
        const uploadArea = uploadAreaResult.area;
        
        // 显示简单的上传提示
        this.showCompletionNotification(0, uploadArea, uploadedContent, useExistingContent, false, '请先上传图片文件，然后系统将自动填写内容');
        
        return {
          contentSuccess: 0,
          hasUploadArea: !!uploadArea,
          hasUploadedContent: uploadedContent.contentElements.length > 0,
          useExistingContent,
          uploadSuccess: false,
          message: '请先上传图片文件，然后系统将自动填写内容'
        };
      }
      
    } catch (error) {
      console.error('自动化发布流程失败:', error);
      this.showCompletionNotification(0, null, null, false, false, error.message);
      throw error;
    }
  }

  // 获取完成提示消息
  getCompletionMessage(uploadedContent, useExistingContent, contentSuccess, uploadSuccess) {
    if (contentSuccess === 0) {
      return '❌ 内容填写失败，请检查页面结构或手动填写';
    } else if (contentSuccess < 2) {
      return `⚠️ 部分内容填写成功 (${contentSuccess}/2)，请检查未填写的项目`;
    } else if (uploadSuccess) {
      return '✅ 内容填写和图片上传都已完成，系统已尝试自动点击发布按钮';
    } else if (this.contentData.imageFiles && this.contentData.imageFiles.length > 0) {
      return '✅ 内容填写完成，需要手动上传图片文件';
    } else if (useExistingContent) {
      return '✅ 已使用平台上的现有内容，内容填写完成，系统已尝试自动点击发布按钮';
    } else if (uploadedContent.contentElements.length > 0) {
      return '✅ 内容填写完成，检测到已上传内容，系统已尝试自动点击发布按钮';
    } else {
      return '✅ 内容填写完成，请手动上传文件并点击发布';
    }
  }

  // 检测发布错误
  async detectPublishError() {
    try {
      console.log('🔍 检测发布错误...');
      
      // 等待一下让错误信息加载
      await new Promise(resolve => setTimeout(resolve, 500));
      
      // 查找小红书特有的错误弹窗
      const errorSelectors = [
        '.creator-publish-toast.error',  // 小红书错误弹窗
        '.creator-publish-toast',        // 小红书弹窗
        '.error-message',
        '.error-msg',
        '.error-text',
        '.alert-error',
        '.alert-danger',
        '.message-error',
        '[class*="error"]',
        '[class*="Error"]',
        '.ant-message-error',
        '.el-message--error'
      ];
      
      for (const selector of errorSelectors) {
        const errorElement = document.querySelector(selector);
        if (errorElement && errorElement.textContent) {
          const errorText = errorElement.textContent.trim();
          if (errorText && errorText.length > 0) {
            console.log('❌ 检测到错误信息:', errorText);
            
            // 检查是否是社区规范相关的错误
            if (errorText.includes('社区规范') || errorText.includes('禁止发笔记') || errorText.includes('违反')) {
              return {
                message: errorText,
                code: 'COMMUNITY_VIOLATION'
              };
            }
            
            // 其他类型的错误
            return {
              message: errorText,
              code: 'PUBLISH_ERROR'
            };
          }
        }
      }
      
      // 使用 MutationObserver 实时监听页面变化，更快地捕获错误弹窗
      return new Promise((resolve) => {
        const observer = new MutationObserver((mutations) => {
          mutations.forEach((mutation) => {
            if (mutation.type === 'childList') {
              mutation.addedNodes.forEach((node) => {
                if (node.nodeType === Node.ELEMENT_NODE) {
                  // 检查是否是错误弹窗
                  if (node.classList && node.classList.contains('creator-publish-toast')) {
                    const errorText = node.textContent || '';
                    console.log('🔍 检测到弹窗元素:', errorText);
                    
                    if (errorText.includes('社区规范') || errorText.includes('禁止发笔记') || errorText.includes('违反')) {
                      console.log('❌ 检测到社区规范错误:', errorText);
                      observer.disconnect();
                      resolve({
                        message: errorText,
                        code: 'COMMUNITY_VIOLATION'
                      });
                    }
                  }
                  
                  // 检查文本内容
                  const text = node.textContent || '';
                  if (text.includes('社区规范') || text.includes('禁止发笔记') || text.includes('违反')) {
                    console.log('❌ 检测到错误文本:', text);
                    observer.disconnect();
                    resolve({
                      message: text,
                      code: 'COMMUNITY_VIOLATION'
                    });
                  }
                }
              });
            }
          });
        });
        
        // 观察页面变化
        observer.observe(document.body, { childList: true, subtree: true });
        
        // 设置超时，避免无限等待
        setTimeout(() => {
          observer.disconnect();
          console.log('✅ 未检测到发布错误');
          resolve(null);
        }, 5000); // 5秒超时
      });
      
      console.log('✅ 未检测到发布错误');
      return null;
      
    } catch (error) {
      console.error('❌ 检测发布错误时发生异常:', error);
      return null;
    }
  }

  // 更新发布记录到数据库
  async updatePublishRecordStatus(recordId, statusData) {
    try {
      console.log('💾 准备更新发布记录状态到数据库...');
      console.log('📋 记录ID:', recordId);
      console.log('📋 状态数据:', statusData);
      
      // 通过 electronAPI 调用更新记录状态
      try {
        console.log('📤 发送更新发布记录状态请求...');
        
        // 检查 electronAPI 是否可用
        if (window.electronAPI && window.electronAPI.updatePublishRecordStatus) {
          console.log('✅ electronAPI 可用，调用更新状态方法...');
          
          const updateResult = await window.electronAPI.updatePublishRecordStatus(recordId, statusData);
          
          if (updateResult.success) {
            console.log('✅ 发布记录状态更新成功:', updateResult.data);
          } else {
            console.error('❌ 发布记录状态更新失败:', updateResult.error);
          }
        } else {
          console.error('❌ electronAPI 不可用，无法更新记录状态');
          console.log('window.electronAPI:', window.electronAPI);
        }
      } catch (error) {
        console.error('❌ 更新记录状态失败:', error);
        console.error('错误详情:', error.stack);
      }
      
    } catch (error) {
      console.error('❌ 更新发布记录状态失败:', error);
    }
  }

  // 关闭发布窗口
  async closePublishWindow() {
    try {
      console.log('🔄 准备关闭发布窗口...');
      
      // 检查 electronAPI 是否可用
      if (window.electronAPI && window.electronAPI.closePublishWindow) {
        console.log('✅ electronAPI 可用，调用关闭窗口方法...');
        
        const closeResult = await window.electronAPI.closePublishWindow();
        
        if (closeResult.success) {
          console.log('✅ 发布窗口关闭成功');
        } else {
          console.error('❌ 发布窗口关闭失败:', closeResult.error);
        }
      } else {
        console.error('❌ electronAPI 不可用，无法关闭窗口');
        console.log('window.electronAPI:', window.electronAPI);
        
        // 备用方案：尝试直接关闭窗口
        try {
          if (window.close) {
            console.log('⚠️ 尝试使用备用方案关闭窗口...');
            window.close();
          }
        } catch (error) {
          console.error('❌ 备用关闭方案也失败:', error);
        }
      }
      
    } catch (error) {
      console.error('❌ 关闭发布窗口失败:', error);
    }
  }

  // 关闭时间选择器弹窗
  async closeDateTimePicker(timeInput) {
    console.log('🔧 开始关闭时间选择器弹窗...');
    
    try {
      // 1. 先失去焦点（这通常会关闭弹窗）
      timeInput.blur();
      console.log('✅ 时间输入框失去焦点');
      
      // 等待一下让弹窗有时间响应
      await new Promise(resolve => setTimeout(resolve, 300));
      
      // 2. 查找并关闭Element UI日期选择器弹窗
      const elPickerSelectors = [
        '.el-picker-panel', 
        '.el-date-picker', 
        '.el-datetime-picker',
        '.el-picker__popper',
        '.el-date-range-picker',
        '.popper[x-placement]'
      ];
      
      for (const selector of elPickerSelectors) {
        const pickerPanel = document.querySelector(selector);
        if (pickerPanel && pickerPanel.style.display !== 'none') {
          console.log(`🎯 找到打开的日期选择器: ${selector}`);
          
          // 尝试点击确认按钮
          const confirmBtn = pickerPanel.querySelector('.el-picker-panel__footer .el-button--primary, .el-button--default:last-child, .confirm-btn, button[type="button"]:last-child');
          if (confirmBtn && confirmBtn.textContent && (confirmBtn.textContent.includes('确定') || confirmBtn.textContent.includes('OK'))) {
            console.log('✅ 找到确认按钮，点击关闭');
            confirmBtn.click();
            await new Promise(resolve => setTimeout(resolve, 200));
            break;
          }
          
          // 如果没有确认按钮，尝试点击空白区域关闭
          console.log('⚠️ 未找到确认按钮，点击空白区域关闭');
          document.body.click();
          await new Promise(resolve => setTimeout(resolve, 200));
          break;
        }
      }
      
      // 3. 查找并关闭其他类型的时间选择器
      const genericPickerSelectors = [
        '.picker-panel',
        '.date-picker',
        '.datetime-picker', 
        '.time-picker',
        '[class*="picker"][class*="panel"]',
        '[class*="date"][class*="picker"]'
      ];
      
      for (const selector of genericPickerSelectors) {
        const picker = document.querySelector(selector);
        if (picker && picker.style.display !== 'none' && picker.offsetHeight > 0) {
          console.log(`🎯 找到通用时间选择器: ${selector}`);
          
          // 尝试点击确认或关闭按钮
          const actionButtons = picker.querySelectorAll('button, .btn, .action-btn, .ok-btn, .confirm-btn');
          let buttonClicked = false;
          
          for (const button of actionButtons) {
            const buttonText = button.textContent || button.innerText || '';
            if (buttonText.includes('确定') || buttonText.includes('确认') || buttonText.includes('OK') || buttonText.includes('保存')) {
              console.log(`✅ 点击按钮关闭选择器: "${buttonText}"`);
              button.click();
              buttonClicked = true;
              break;
            }
          }
          
          if (!buttonClicked) {
            // 如果没找到合适的按钮，点击空白区域
            console.log('⚠️ 未找到合适的按钮，点击空白区域');
            document.body.click();
          }
          
          await new Promise(resolve => setTimeout(resolve, 200));
          break;
        }
      }
      
      // 4. 强制关闭所有可能的弹窗
      console.log('🔄 执行强制关闭操作...');
      
      // 按ESC键关闭弹窗
      try {
        const escEvent = new KeyboardEvent('keydown', {
          key: 'Escape',
          code: 'Escape', 
          keyCode: 27,
          which: 27,
          bubbles: true
        });
        document.dispatchEvent(escEvent);
        console.log('✅ 发送ESC键事件');
      } catch (e) {
        console.log('⚠️ ESC键事件失败:', e.message);
      }
      
      // 点击页面其他区域确保关闭
      const clickTargets = [
        document.body,
        document.querySelector('.main-content'),
        document.querySelector('.page-content'), 
        document.querySelector('.container'),
        document.documentElement
      ].filter(el => el);
      
      for (const target of clickTargets) {
        try {
          target.click();
          console.log('✅ 点击页面区域关闭弹窗');
          break;
        } catch (e) {
          continue;
        }
      }
      
      // 等待弹窗关闭动画完成
      await new Promise(resolve => setTimeout(resolve, 500));
      
      // 5. 验证弹窗是否已关闭
      const openPickers = document.querySelectorAll('.el-picker-panel:not([style*="display: none"]), .picker-panel:not([style*="display: none"])');
      if (openPickers.length === 0) {
        console.log('✅ 所有时间选择器弹窗已关闭');
      } else {
        console.log(`⚠️ 仍有 ${openPickers.length} 个弹窗未关闭`);
      }
      
      // 6. 最终确认：再次触发时间输入框的事件
      timeInput.focus();
      await new Promise(resolve => setTimeout(resolve, 100));
      timeInput.blur();
      timeInput.dispatchEvent(new Event('change', { bubbles: true }));
      
      console.log('✅ 时间选择器关闭操作完成');
      
    } catch (error) {
      console.error('❌ 关闭时间选择器失败:', error);
    }
  }

  // 显示完成提示
  showCompletionNotification(contentSuccess, uploadArea, uploadedContent, useExistingContent, uploadSuccess, errorMessage = null) {
    const notification = document.createElement('div');
    
    if (errorMessage) {
      // 错误提示
      notification.style.cssText = `
        position: fixed;
        top: 20px;
        right: 20px;
        background: #f44336;
        color: white;
        padding: 15px 20px;
        border-radius: 8px;
        z-index: 10000;
        font-family: Arial, sans-serif;
        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
        max-width: 400px;
      `;
      notification.innerHTML = `❌ 自动化失败<br>${errorMessage}`;
    } else {
      // 成功提示
      notification.style.cssText = `
        position: fixed;
        top: 20px;
        right: 20px;
        background: #4CAF50;
        color: white;
        padding: 15px 20px;
        border-radius: 8px;
        z-index: 10000;
        font-family: Arial, sans-serif;
        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
        max-width: 400px;
      `;
      
      let message = `✅ 自动化流程完成！<br>`;
      
      if (contentSuccess === 0) {
        message += '❌ 内容填写失败，请检查页面';
      } else if (contentSuccess < 2) {
        message += `⚠️ 部分内容填写成功 (${contentSuccess}/2)`;
      } else {
        message += '✅ 内容填写完成';
      }
      
      if (uploadSuccess) {
        message += '<br>📁 文件上传完成';
      }
      
      message += '<br>请检查内容并点击发布';
      
      notification.innerHTML = message;
    }
    
    document.body.appendChild(notification);
    
    // 8秒后自动隐藏
    setTimeout(() => {
      notification.remove();
    }, 8000);
  }
}

// 导出工具类
if (typeof module !== 'undefined' && module.exports) {
  module.exports = ContentFiller;
} else {
  window.ContentFiller = ContentFiller;
}